#include  "Enseignement.h"


/** @brief initEnseignement
  *
  * @todo: document this function
  */
void initEnseignement(Enseignement * enseignement, int numEnseignement,  int numEns,  int codeUE, int type, char * date, int duree,  int numSalle,  char groupe)
{
    assert(enseignement!=NULL);
    enseignement->numEnseignement=numEnseignement;
    enseignement->numEns=numEns;
    enseignement->codeUE=codeUE;
    enseignement->type=type;
    enseignement->date=date;
    enseignement->duree=duree;
    enseignement->numSalle=numSalle;
    enseignement->groupe=groupe;
}

/** @brief libEnseignement
  *
  * @todo: document this function
  */
void libEnseignement(Enseignement * enseignement)
{
    assert(enseignement!=NULL);
    enseignement->numEnseignement=0;
    enseignement->numEns=0;
    enseignement->codeUE=0;
    enseignement->type=0;
    enseignement->date=NULL;
    enseignement->duree=0;
    enseignement->numSalle=0;
    enseignement->groupe='0';
}

/** @brief creEnseignement
  *
  * @todo: document this function
  */
Enseignement* creEnseignement( int numEnseignement, int numEns,  int codeUE, int type,  char * date, int duree, int numSalle,  char groupe)
{
    Enseignement*enseignement=calloc(1,sizeof(Enseignement));
    initEnseignement(enseignement,numEnseignement,numEns,codeUE,type, date,duree,numSalle, groupe);

    return  enseignement;
}

/** @brief detEnseignement
  *
  * @todo: document this function
  */
void detEnseignement(Enseignement ** enseignement)
{
    libEnseignement(*enseignement);
    free(*enseignement);
    *enseignement=NULL;
}

/** @brief getNumEns_Enseignement
  *
  * @todo: document this function
  */
int getNumEns_Enseignement( Enseignement * enseignement)
{
    assert(enseignement!=NULL);

    return  enseignement->numEns;
}

/** @brief setNumEns_Enseignement
  *
  * @todo: document this function
  */
void setNumEns_Enseignement(Enseignement * enseignement, int numEns)
{
    assert(enseignement!=NULL);
    enseignement->numEns=numEns;
}

/** @brief getCodeEU_Enseignement
  *
  * @todo: document this function
  */
int getCodeEU_Enseignement( Enseignement * enseignement)
{
    assert(enseignement!=NULL);

    return  enseignement->codeUE;
}

/** @brief setCodeUE_Enseignement
  *
  * @todo: document this function
  */
void setCodeUE_Enseignement(Enseignement * Enseignement, int codeUE)
{

}

/** @brief getDate_Enseignement
  *
  * @todo: document this function
  */
char* getDate_Enseignement( Enseignement * enseignement)
{
    assert(enseignement!=NULL);
    return  enseignement->date;
}

/** @brief setDate_Enseignement
  *
  * @todo: document this function
  */
void setDate_Enseignement(Enseignement * enseignement, char * date)
{
    assert(enseignement!=NULL);
    enseignement->date=date;
}

/** @brief getNumSalle_Enseignement
  *
  * @todo: document this function
  */
int getNumSalle_Enseignement( Enseignement * enseignement)
{
    assert(enseignement!=NULL);
    return  enseignement->numSalle;
}

/** @brief setNumSalle_Enseignement
  *
  * @todo: document this function
  */
void setNumSalle_Enseignement(Enseignement * enseignement, int numSalle)
{
    assert(enseignement!=NULL);
    enseignement->numSalle=numSalle;
}

/** @brief getGroupe_Enseignement
  *
  * @todo: document this function
  */
char getGroupe_Enseignement( Enseignement * enseignement)
{
    assert(enseignement!=NULL);
    return enseignement->groupe;
}

/** @brief setGroupe_Enseignement
  *
  * @todo: document this function
  */
void setGroupe_Enseignement(Enseignement * enseignement, char groupe)
{
    assert(enseignement!=NULL);
    enseignement->groupe=groupe;
}

/** @brief affEnseignement
  *
  * @todo: document this function
  */
void affEnseignement( Enseignement * Enseignement)
{

}

/** @brief savEnseignementParElem
  *
  * @todo: document this function
  */
void savEnseignementParElem( int numEnseignement,int codeUE, int numEns,int type,  char * date, int  duree, int numSalle,  char groupe)
{
    FILE* f;

    f = fopen(ENSEIGNEMENT_DB, "a");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", IP_DB);
        exit(EXIT_FAILURE);
    }
    fclose(f);
    if(recEnseignementParCode(numEnseignement) ==NULL)
    {
        f = fopen(ENSEIGNEMENT_DB, "a");

        char*c_numEnseignement=calloc(20,sizeof(char));
        char*c_codeUe=calloc(20,sizeof(char));
        char*c_numEns=calloc(20,sizeof(char));
        char*c_type=calloc(20,sizeof(char));
        char*c_duree=calloc(1,sizeof(char));
        char*c_numSalle=calloc(5,sizeof(char));
        sprintf(c_codeUe,"%d",codeUE);
        sprintf(c_numEnseignement,"%d",numEnseignement);
        sprintf(c_numEns,"%d",numEns);
        sprintf(c_type,"%d",type);
        sprintf(c_numSalle,"%d",numSalle);
        sprintf(c_duree,"%d",duree);
        char*c_groupe=calloc(1,sizeof(char));
        sprintf(c_groupe,"%c",groupe);
        char*chaine=calloc(100,sizeof(char));

        strcat(chaine,c_numEnseignement);
        strcat(chaine,":");
        strcat(chaine,c_codeUe);
        strcat(chaine,":");
        strcat(chaine,c_numEns);
        strcat(chaine,":");
        strcat(chaine,c_type);
        strcat(chaine,":");
        strcat(chaine,date);
        strcat(chaine,":");
        strcat(chaine,c_duree);
        strcat(chaine,":");
        strcat(chaine,c_numSalle);
        strcat(chaine,":");
        strcat(chaine,c_groupe);
        strcat(chaine,"\n");

        fputs(chaine, f);
        free(c_groupe);
        free(c_numSalle);
        free(c_type);
        free(c_duree);
        free(c_numEns);
        free(c_codeUe);
        free(c_numEnseignement);
        free(chaine);
        fclose(f);
    }
    /* TODO (salah#1#): Ecrire dans un fichier les information sur une Ip
    ne pas oublier de rajouter une fonction qui liste toutes les ip d'un etudiant(numEtu) et une qui liste tout les etudiants insrit a la meme ue(codeue) */
    else
    {
        printf("Enseignement deja present dans  la  BD !!!!!\n");
    }
}

/** @brief recEnseignementParCode
  *
  * @todo: document this function
  */
Enseignement* recEnseignementParCode( int numEnseignement)
{
    FILE* f;

    f = fopen(ENSEIGNEMENT_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNEMENT_DB);
        exit(EXIT_FAILURE);
    }

    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
    {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(numEnseignement==atoi(tab[0]))
        {
            char    grp=(char)*tab[7];
            fclose(f);
            free(tabor);
            return  creEnseignement(atoi(tab[0]),atoi(tab[1]),atoi(tab[2]),atoi(tab[3]),tab[4],atoi(tab[5]),atoi(tab[6]),grp);
        }
        free(tabor);
        free(tab);
    }

    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    return  NULL;
}

/** @brief supEnseignemeent
  *
  * @todo: document this function
  */
int supEnseignemeent(Enseignement*enseignement)
{
    assert(enseignement!=NULL);
    return  supEnseignementParCode(enseignement->numEnseignement);
}



/** @brief supEnseignementParCode
  *
  * @todo: document this function
  */
int supEnseignementParCode( int numEnseignement)
{
    char *contenu=calloc(100,sizeof(char));
    FILE * fIn;
    FILE * fOut;

    if ((fIn = fopen(ENSEIGNEMENT_DB, "r")) == NULL)
        return EXIT_FAILURE;

    if ((fOut = fopen("texte.tmp", "w")) == NULL)
    {
        fclose(fIn);
        return EXIT_FAILURE;
    }

    while (fgets(contenu,100, fIn))
    {
        char * ligne=calloc(100,sizeof(char));
        strcpy(ligne,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) != numEnseignement)
            fputs(ligne, fOut);

         free(ligne);
         free(tabor);
         free(tab);
    }
    free(contenu);
    fclose(fIn);
    fclose(fOut);

    rename("texte.tmp", ENSEIGNEMENT_DB);
    return 0;
}

/** @brief mdfEnseignementParCode
  *
  * @todo: document this function
  */
int mdfEnseignementParCode( int numEnseignement, Enseignement *pEnseignement)
{
    assert(numEnseignement>0    &&  pEnseignement!=NULL);
    supEnseignementParCode(numEnseignement);
    saveEnseignement(pEnseignement);
    return  0;
}

/** @brief affEnseignement_DB
  *
  * @todo: document this function
  */
void affEnseignement_DB()
{

}

char *  getEnseignementText(Enseignement*enseignement,char*separateur)
{
    assert(enseignement!=NULL);
    char*text=calloc(100,sizeof(char));
    char* type=NULL;
    type=calloc(2,sizeof(char));
    char*duree=calloc(10,sizeof(char));
    char*groupe=calloc(4,sizeof(char));


    if(enseignement->type==1)
    {
        type="CM";
        sprintf(groupe,"%s","Tous");
    }
    else    if(enseignement->type==2)
    {
        type="TD";
        sprintf(groupe,"%c",enseignement->groupe);
    }
    else    if(enseignement->type==3)
    {
        type="TP";
        sprintf(groupe,"%c",enseignement->groupe);
    }
    sprintf(duree,"%d",enseignement->duree);


    strcat(text,recUEParCode(enseignement->codeUE)->intitule);
    strcat(text,separateur);

    strcat(text,type);
    strcat(text,separateur);

    strcat(text,"Groupe: ");
    strcat(text,groupe);
    strcat(text,separateur);

    strcat(text,"Par:   ");
    strcat(text,recEnsParCode(enseignement->numEns)->nomEns);
    strcat(text,separateur);

    strcat(text, enseignement->date);
    strcat(text,separateur);

    strcat(text,"Durée(min):    ");
    strcat(text,duree);
    strcat(text,separateur);

    strcat(text,"Lieu:    ");
    strcat(text,recSalleParCode(enseignement->numSalle)->intitule);



    free(duree);
    free(groupe);

    return    text;
}

/** @brief modifEnseignement
 *
 * @todo: document this function
 */
int modifEnseignement(Enseignement*enseignement, Enseignement*enseignementnew)
{
    assert(enseignement!=NULL   &&  enseignementnew!=NULL);
    assert(enseignement->numEnseignement==enseignementnew->numEnseignement);

    return  mdfEnseignementParCode(enseignement->numEnseignement,enseignementnew);
}

/** @brief recEnseignementParNumEtu
  *
  * @todo: document this function
  */
TabEnseignement* recEnseignementParNumEtu(int numEtu)
{
    int i=1,j=0;
    Enseignement ** enseignements=calloc(i,sizeof(Enseignement));
    TabUe * tabUe=recUeParNumEtu(numEtu);

    FILE* f;

    f = fopen(ENSEIGNEMENT_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNEMENT_DB);
        return  NULL;
    }

    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
    {
        j=0;
        char *  dest=NULL;
        dest=(char*)calloc(100,sizeof(char));
        strcpy(dest,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        while(j<tabUe->nbUe)
        {
            if((tabUe->tabUe[j])->codeUE==atoi(tab[1]))
            {
                IP* ip=recIpParCodeUeNumEtu(numEtu,tabUe->tabUe[j]->codeUE);
                char*c_gr=calloc(1,sizeof(char));
                sprintf(c_gr,"%c",ip->groupe);
                if(atoi(tab[3])==1  ||  strcmp(tab[7],c_gr)==0)
                {
                    enseignements=realloc(enseignements,sizeof(Enseignement)*i);
                    char    grp=(char)*tab[7];
                    char*date=(char*)calloc(30,sizeof(char));
                    strcpy(date,tab[4]);
                    enseignements[i-1]=creEnseignement(atoi(tab[0]),atoi(tab[1]),atoi(tab[2]),atoi(tab[3]),date,atoi(tab[5]),atoi(tab[6]),grp);
                    i++;
                }
                free(c_gr);
                detIP(&ip);
            }
            j++;
        }
        free(tabor);
        free(tab);
    }
    free(contenu);

    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    if(i>1)
    {
        TabEnseignement *tabEnseignement=calloc(1,sizeof(TabEnseignement));
        tabEnseignement->tabEnseignement=enseignements;
        tabEnseignement->nbEnseignement=i-1;
        return tabEnseignement;
    }
    return  NULL;
}

/** @brief recEnseignementParEtu
  *
  * @todo: document this function
  */
TabEnseignement* recEnseignementParEtu(Etu*etu)
{
    assert(etu!=NULL    &&  etu->numEtu>0);

    return  recEnseignementParNumEtu(etu->numEtu);
}

/** @brief recEnseignementParNumEns
  *
  * @todo: document this function
  */
TabEnseignement* recEnseignementParNumEns(int numEns)
{
    int i=1;
    Enseignement**enseignements=calloc(i,sizeof(Enseignement));
    FILE* f;

    f = fopen(ENSEIGNEMENT_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", IP_DB);
        exit(EXIT_FAILURE);
    }

    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
    {
        /*omid
        char * dest=calloc(100,sizeof(char));
        copStr(&dest,contenu);
        */
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(numEns==atoi(tab[2]))
        {
            enseignements=realloc(enseignements,sizeof(Enseignement)*i);
            char    grp=(char)*tab[7];
            enseignements[i-1]=creEnseignement(atoi(tab[0]),atoi(tab[1]),atoi(tab[2]),atoi(tab[3]),tab[4],atoi(tab[5]),atoi(tab[6]),grp);
            i++;
        }
        free(tabor);
        free(tab);
    }
    free(contenu);

    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    if(i>1)
    {
        TabEnseignement *tabEnseignement=calloc(1,sizeof(TabEnseignement));
        tabEnseignement->tabEnseignement=enseignements;
        tabEnseignement->nbEnseignement=i-1;
        return tabEnseignement;
    }
    return  NULL;
}

/** @brief recEnseignementParEnseignant
  *
  * @todo: document this function
  */
TabEnseignement* recEnseignementParEnseignant(Ens *ens)
{
    assert(ens!=NULL && ens->numEns>0);
    return  recEnseignementParNumEns(ens->numEns);
}

/** @brief recEnseignementParCodeUe
  *
  * @todo: document this function
  */
TabEnseignement* recEnseignementParCodeUe(int codeUe)
{
    int i=1;
    Enseignement ** enseignements=calloc(i,sizeof(Enseignement));
    FILE* f;

    f = fopen(ENSEIGNEMENT_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", IP_DB);
        exit(EXIT_FAILURE);
    }

    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
    {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(codeUe==atoi(tab[1]))
        {
            enseignements=realloc(enseignements,sizeof(Enseignement)*i);
            char    grp=(char)*tab[7];
            enseignements[i-1]=creEnseignement(atoi(tab[0]),atoi(tab[1]),atoi(tab[2]),atoi(tab[3]),tab[4],atoi(tab[5]),atoi(tab[6]),grp);
            i++;
        }
        free(tabor);
        free(tab);
    }
    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    if(i>1)
    {
        TabEnseignement *tabEnseignement=calloc(1,sizeof(TabEnseignement));
        tabEnseignement->tabEnseignement=enseignements;
        tabEnseignement->nbEnseignement=i-1;
        return tabEnseignement;
    }
    return  NULL;
}

/** @brief recEnseignementParUe
  *
  * @todo: document this function
  */
TabEnseignement* recEnseignementParUe(UE*ue)
{
    assert(ue!=NULL &&  ue->codeUE>0);
    return  recEnseignementParCodeUe(ue->codeUE);
}

/** @brief saveEnseignement
  *
  * @todo: document this function
  */
void saveEnseignement(Enseignement*enseignement)
{
    assert(enseignement!=NULL);
    savEnseignementParElem(enseignement->numEnseignement,enseignement->codeUE,enseignement->numEns,enseignement->type,enseignement->date,enseignement->duree,enseignement->numSalle,enseignement->groupe);
}



char* recPresenceEtuAEnseignement(Etu*etu,Enseignement*enseignement)
{
    assert(etu!=NULL    &&  enseignement!=NULL);
    return  recPresenceEtuAEnseignementParId(etu->numEtu,enseignement->numEnseignement);
}



/** @brief setPresenceEtuAEnseignement
  *
  * @todo: document this function
  */
void setPresenceEtuAEnseignement(Etu*etu,Enseignement*enseignement,char* etat)
{
    setPresenceParNumEtuNumEnseignement(etu->numEtu,enseignement->numEns,etat);
}

void setPresenceParNumEtuNumEnseignement(int numEtu,int  numEnseignement,char* etat)
{
    FILE* f;

    f = fopen(PRESENCE_DB, "a");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", PRESENCE_DB);
        exit(EXIT_FAILURE);
    }
    fclose(f);
    if(recPresenceEtuAEnseignementParId(numEtu,numEnseignement) ==NULL)
    {
        f = fopen(PRESENCE_DB, "a");

        char*c_numEnseignement=calloc(20,sizeof(char));
        char*c_numEtu=calloc(20,sizeof(char));

        sprintf(c_numEtu,"%d",numEtu);
        sprintf(c_numEnseignement,"%d",numEnseignement);

        char*chaine=calloc(100,sizeof(char));

        strcat(chaine,c_numEnseignement);
        strcat(chaine,":");
        strcat(chaine,c_numEtu);
        strcat(chaine,":");
        strcat(chaine,etat);
        strcat(chaine,"\n");

        fputs(chaine, f);

        free(chaine);
        free(c_numEnseignement);
        free(c_numEtu);

        fclose(f);
    }
    else
    {
        supPresenceDeDB(numEtu,numEnseignement);
        setPresenceParNumEtuNumEnseignement(numEtu,numEnseignement,etat);
    }
}

char*recPresenceEtuAEnseignementParId(int    numEtu,int  numEnseignement)
{
    char *contenu=calloc(100,sizeof(char));
    FILE * f;

    if ((f = fopen(PRESENCE_DB, "r")) == NULL)
    {
        return NULL;
    }

    while (fgets(contenu,100, f))
    {
        char * ligne=calloc(100,sizeof(char));
        strcpy(ligne,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) == numEnseignement &&  atoi(tab[1])==numEtu)
        {
            fclose(f);
            free(ligne);
            free(tabor);
            return  tab[2];
        }
        free(ligne);
        free(tabor);
        free(tab);
    }
    free(contenu);

    fclose(f);

    return  NULL;
}

int supPresenceDeDB(int numEtu,int  numEnseignement)
{

    char *contenu=calloc(100,sizeof(char));
    FILE * fIn;
    FILE * fOut;

    if ((fIn = fopen(PRESENCE_DB, "r")) == NULL)
        return EXIT_FAILURE;

    if ((fOut = fopen("texte.tmp", "w")) == NULL)
    {
        fclose(fIn);
        return EXIT_FAILURE;
    }

    while (fgets(contenu,100, fIn))
    {
        char * ligne=calloc(100,sizeof(char));
        copStr(&ligne,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) != numEnseignement &&  atoi(tab[1])!=numEtu)
            fputs(ligne, fOut);

        free(ligne);
        free(tabor);
        free(tab);
    }

    free(contenu);
    fclose(fIn);
    fclose(fOut);

    rename("texte.tmp", PRESENCE_DB);
    return  0;
}


/** @brief recEtuParEnseignement
  *
  * @todo: document this function
  */
TabEtu* recEtuParEnseignement(Enseignement*enseignement)
{
    TabEtu*tabEtu=recEtuInscritParCodeUe(enseignement->codeUE);
    int i=0;
    TabEtu  *   tab=calloc(1,sizeof(TabEtu));
    Etu**   etus=calloc(1,sizeof(Etu));
    int j=1;

    while(i<tabEtu->nbEtu)
    {
        char*c_gr=calloc(2,sizeof(char));
        IP* ip=recIpParCodeUeNumEtu(tabEtu->tabEtu[i]->numEtu,enseignement->codeUE);
        sprintf(c_gr,"%c",ip->groupe);
        char*c_gr1=calloc(2,sizeof(char));
        sprintf(c_gr1,"%c",enseignement->groupe);
        if(strcmp(c_gr,c_gr1)==0 || enseignement->type==1)
        {
            etus=realloc(etus,sizeof(Etu)*j);
            etus[j-1]=creEtu(tabEtu->tabEtu[i]->numEtu,tabEtu->tabEtu[i]->nomEtu,tabEtu->tabEtu[i]->prenomEtu);
            j++;
        }
        i++;
        free(c_gr);
        free(c_gr1);
    }
    tab->nbEtu=j-1;
    tab->tabEtu=etus;

    return  tab;
}

/** @brief regEnseignement
  *
  * @todo: document this function
  */
void regEnseignement()
{

}
